Remove some more gtk_widget_get_content_size uses

widgetbowl: Add some more widget types

testswitch: Remove unnecessary gtk_widget_show calls

image: Stop using gtk_widget_get_content_size

popover: Stop using gtk_widget_get_content_size

spinner: Stop using gtk_widget_get_content_size

gsk: Remove gsk_render_node_set_scaling_filters()

This is a leftover from the very early rendernode that we forgot to delete.

This can be seen by the fact that it is settable on an immutable object.

Use Unicode quotation marks in new strings

See https://developer.gnome.org/hig/stable/typography.html

https://bugzilla.gnome.org/show_bug.cgi?id=772371

Update POTFILES.in

GDK W32: Remove stray debug code

I have no idea how this slipped into master (these two lines are not present
in the same commit that went into gtk-3-22).

dnd: Remove unused variables

Remove GdkDragProtocol from the api

...together with apis that return it. We were not using this
information in GTK+ at all, so no need to provide it.

Drop api that is only for unmanaged dnd

These functions are not needed as public api anymore.

dnd: Handle rootwin drop in gdk

This lets us drop the only use of the drag protocol in gtk.

dnd: Remove much of the unmanaged dnd

wayland: Add primary clipboard subclass

I decided to put this in a custom subclass, because then I could keep
the whole gtk primary protocol self-contained.

The other option would have been reusing GdkWaylandClipboard, but that
didn't seem worth it, especially because that code needs to interact
with the DND machinery, while the primary doesn't.

wayland: Implement taking over the clipboard

The clipboard is now complete.
That was fast.

wayland: Implement reading the clipboard

We now keep track of what's in the clipboard and allow people to read
its contents.

wayland: Add skeleton for a GdkClipboardWayland

Creates the source file and a custom subclass and makes sure it's used
by GDK.

gdk: Get rid of owner change events

They're unused now.

gtk: Remove GtkClipboard

icon-browser: Port to new clipboard

gtk-demo: Port to GdkClipboard

clipboard: Change image convenience APIs

Don't use pixbufs anymore, use textures.

gdk: Add (de)serializers for GDK_TYPE_TEXTURE

We want to use textures more, so we should be able to use them for
copy/paste and dnd.

x11: Handle case where clipboard was reclaimed quickly

When the reply to a TARGETS request comes in, the clipboard may already
be reclaimed by the local app. Deal with that case (in an ugly way,
strictly speaking we should use a cancellable here).

This happens for example at startup when the initial TARGETS requests
have not been answered until after the main widow popped up. And if such
a window immediately claims the primary clipboard (like when the initial
focus is inside an entry), this race will happen.

entry: Port to GdkClipboard

x11: Implement storing the clipboard

x11: Implement MULTIPLE requests

tests: Don't crash if widgets go away before clipboard

Don't g_signal_connect() to the clipboard without protection - the
clipboard might outlast you and still emit signals.

x11: Introduce GdkX11PendingSelectionNotify

This object tracks the SelectionNotifyEvent that has to be sent in
response to a SelectionRequest.

Currently it just looks like code reshuffling, but it's a prerequisite
for handling MULTIPLE, which requires to only send the notify after
every stream has writtten at least once.

But anyway, code is cleaner now, so it's a win!

x11: Split out a function

This will be necessary for MULTIPLE handling.

main: Implement storing all clipboards

application: Put shared code into a common function

clipboard: Add infrastructure to store clipboards

Clipboard managers will be so happy once the backends actually implement
it!

contentprovider: Add ref_storable_formats()

This is to be used for advocating to clipboard managers.

filechooserwidget: Port to new clipboard

We use the new GDK_TYPE_FILE_LIST here.

gdk: Add GDK_TYPE_FILE_LIST with serializers

This is a GSList of GFile and we want it so we can operate with lists of
files and text/uri-list.

I chose GSList over GList because that's what the GtkFileChooser API
uses, too.

gdk: Add serializers and deserializers for GFile

in particular, support:
GFile <=> text/uri-list
GFile  => text/plain

tests: Improve formats list for testclipboard2

label: Port to new clipboard

textview: Redo clipboard handling

Instead of using GtkClipboard and handling everything ourselves, we now
put GtkTextBuffer into the GdkClipboard and register (de)serializers for
text/plain.

gdk: Add gdk_content_formats_new_for_gtype()

Many places create formats for a single tpye, so make it easy for them
to get this without having to create a builder first.

gdk: Allow setting task data on (de)serializers

This mirrors GTask.

gtk-demo: Port clipboards example to new clipboard

recentchooser: Port to GdkClipboard

linkbutton: Port to GdkClipboard

a11y: Port to GdkClipboard

widget: Add gtk_widget_get_clipboard()

... and gtk_widget_get_primary_clipboard().

They both give out the new GdkClipboard.

widget: gtk_widget_get_clipboard => gtk_widget_get_old_clipboard

Just rename the function, so the previous one can be used for the
new clipboard.

tests: Open a 2nd display in testclipboard2

This allows testing local transfer of data as well as remote transfer
(by transferring data between clipboards of both Displays).

x11: Implement claiming the X Selection with the clipboard

... and of course support writing to other apps.

tests: Add possibility to set invalid UTF-8 and clear clipboard

x11: Add gdk_x11_display_get_max_request_size()

There's multiple places in the clipboard code where I need it, so make
it a custom function.

clipboard: Allow claiming the clipboard to fail

Also make clipboard_claim() a vfunc so backends can override it.

Because the whole operation a vfunc, backends have the option of adding
code before the actual claim is done and potentially even fail or do
something after the successful claim.

gdkcontentformats: Change the matching API

Instead of having just one function that has the gtype and mime type as
out arguments, have 3 functions: 1 that finds any match, 1 that finds a
GType match and one for a mime type match.

This makes the API way more convenient to use.

clipboard: Add serialization

This completes the local clipboard code.

clipboard: Implement local fallback clipboard transfers

This requires implementing a "pipe" so we can have 2 streams running:
  contentprovider => serializer => outputstream
  inputstream => deserializer => reader
And the pipe shoves the data from the outputstream into the inputstream.

clipboard: Introduce GdkContentProvider

GdkContentProvider is the object that represents local data in the
clipboard.

This patch only introduces the object and adds the clipboard properties,
it does not yet provide a way for the actual implementations to access
it.

The only access that is implemented is the local shortcut GValue access.

clipboard: Make value getters set the passed in value

Don't return a const GValue, that's ugly API. Instead require people to
pass in a preinitialized GValue and set that one.

x11: Improve fallbacks for text

(1) Try all passed in formats in order if one of them fails.
(2) Don't blindly accept all formats, make sure they are mime types
(3) Add a bunch of special non-mime types that plug converters to
    get to mime types

clipboard: Add gdk_clipboard_read_text_async()

Also add deserializers for G_TYPE_STRING.

clipboard: Add gdk_clipboard_read_pixbuf_async()

gdk: Im[plement content deserializing

Add infrastructure to do GInputStream => GType conversions. Use that to
implement gdk_clipboard_read_value() which reads into GValues.

x11: Improve debugging output for selection input stream

clipboard: Refactor gdk_clipboard_read() to be async

This allows us not just to pass any mime type to the read function, but
it also makes it possible to pass multiple mime types and the clipboard
can then try them in order until it finds a supported one.

This is so far not implemented though.

x11: Use async queue and implement sync reads on selections stream

Turns out, way too many async operations are implemented by running the
sync operation in a thread. The easiest solution is to support that is
to use a GAsyncQueue for the buffers and deadlock if called from the
main thread.

tests: Add a new test app for GdkClipboard

clipboard: Implement gdk_clipboard_read()

x11: Implement INCR reads

x11: Various clipboard cleanups

(1) Turn X11 clipboard event handling into a regular filter function
(2) Maintain a timestamp in the clipboard, so we can pass it when
    querying selections.

clipboard: Add gdk_clipboard_claim_remote()

This allows the remote clipboard to take over. The X11 clipboard already
does that.

x11: Add an initial clipboard implementation

This does nothing but download the targets and debug-print them.

gdk: A GdkClipboard API draft

This commit adds a GdkClipboard object which is intended to
replace GtkClipboard, eventually.

GDK W32: Plug a resource leak

Ensure that surfaces allocated in the impl are destroyed in finalize()

https://bugzilla.gnome.org/show_bug.cgi?id=787089

Update Polish translation

dnd: Add gtk_drag_set_icon_texture()

selection: Add texture getter/setter

image: Add gtk_image_new_from_texture()

Docs and header knew about this function.
There just was no implementation.

image: Store pixbufs as textures, not surfaces

vulkan: Fix mask shader to premultiply color

The inColor wasn't premultiplied, so the resulting colors were wrong
with translucent borders.

vulkan: Fix border shader to premultiply color

The inColor wasn't premultiplied, so the resulting colors were wrong
with translucent borders.

GDK W32: Remove an unnecessary type check

No idea why it's here, the hash table can store any kind of data,
there's no reason why it wouldn't be able to store an old X string type.
Might be a holdout from the old days, when strings were handled in
a special way (stored directly in the clipboard?).

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Make sure drag source window is not NULL

This prevents GTK from throwing a bunch of warnings when it tries
to get drag source window -> screen of that window -> ipc widget for that screen,
and then tries to attach a signal handler to that widget.

Specifically, this happens when we get a DnD move from another
application.

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Special handling for DELETE requests

1) Ensure that any DELETE requests from the target are sent to GDK, even if
   both the source and the target are in the same process and it
   is therefore possible to use a shortcut and call the handler directly
   in GTK layer
2) Ensure that target GDK doesn't do anything when GTK asks it to send
   a DELETE request, just report back immediately (the code up the stack
   does not check for successfullness when request is DELETE, so not giving
   it any data is OK).

The source code already synthesizes a DELETE request, so that side is
also taken care of.

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Preserve the target value for change_property()

We need to know the target atom value to know when we need to
do something with side-effects (since side-effects are expressed via
special target values). Previously, the code side-stepped that by looking
at the data type (which was rather unique for the one side-effect
target that we supported, signalled by the TARGETS target),
but for the DELETE target that seems to be no longer an option, hence the new
field to carry this information past the convert_selection() routine.

This prevents GDK from throwing a warning when trying to convert
a DELETE target, which has no format or data objects set.

The side-effects for the DELETE target happen earlier, in GTK layer.
By the point it gets to change_property(), it's a no-op.

https://bugzilla.gnome.org/show_bug.cgi?id=786509

Fix a nefarious typo

GDK W32: Ensure that selection request is processed

To do that, run the message loop for one second or until the side-effect
of running the selection request handler is achieved (as opposed to
running it until the event is no longer queued).

The disavantage of this method is that if the event handling is
somehow missed (due to a variety of reasons - after all, it's not
a straight path from an event being queued to property_change()
being called), this will loop for one second. Since we do process
events during that time, this will not hang the application, but
might still restrict some of the functionality.

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Refuse to release mouse grab while in DnD mode

Handle WM_CANCELMODE and do nothing in response to it when DnD is
active. Otherwise pass it to DefWindowProc, which will call ReleaseCapture()
on our behalf.
This prevents us from losing mouse capture when alt-tabbing during DnD
(this includes the feature of Windows Explorer where dragging stuff over
a window button in the taskbar causes that window to receive focus, i.e.
keyboardless alt-tabbing).

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Update layered windows on opacity changes

Without this patch layered windows are only updated when they are moved
by the user or then their contents changes. This patch adds opacity
changes to the list of things that make GDK update a window. Without this
windows that don't redraw and are not moved by the used (DnD drag indicator
windows, for example) don't change their opacity.

(This commit is cherry-picked from the gtk-3-22 branch)

https://bugzilla.gnome.org/show_bug.cgi?id=786509

W32: Massive W32 DnD fix

Massive changes to OLE2 DnD protocol, which was completely broken before:
* Keep GdkDragContext and OLE2 objects separate (don't ref/unref them
  together, don't necessarily create them together).
* Keep IDataObject formats in the object itself, not in a global variable.
* Fix getdata() to look up the request target in its format list, not in the
  global hash table
* Create target GdkDragContext on each drag_enter, destroy it on drag_leave,
  whereas IDropTarget is created when a window becomes a drag destination
  and is re-used indefinitely.
* Query the source IDataObject for its supported types, cache them in the
  target (!) context. This is how GTK+ works, honestly.
* Remember current_src_object when we initiate a drag, to be able
  to detect later on that the data object is ours and use a
  shortcut when querying targets
* Make sure GDK_DRAG_MOTION is only sent when something changes
* Support GTK drag cursors
* Ensure that exotic GTK clipboard formats are registered
  (but try to avoid registering formats that can't be used between applications).
* Don't enumerate internal formats
* Ensure that DnD indicator window can't accept drags or receive any kind of input
  (use WS_EX_TRANSPARENT).
* Remove unneeded indentation in _gdk_win32_dnd_do_dragdrop()
* Fix indentation in gdk_win32_drag_context_drop_finish()
* Remove obsolete comments in _gdk_win32_window_register_dnd()
* Check for DnD in progress when processing WM_KILLFOCUS, don't emit a grab
  break event in such cases (this allows alt-tabbing while DnD is in progress,
  though there may be lingering issues with focus after dropping...)
* Support Shell ID List -> text/uri-list conversion, now it's possible
  to drop files (dragged from Explorer) on GTK+ applications
* Explicitly use RegisterClipboardFormatA() when we know that the string
  is not in unicode. Otherwise explicitly use RegisterClipboardFormatW()
  with a UTF8->UTF16 converted string
* Fix _gdk_win32_display_get_selection_owner() to correctly bail
  when selection owner HWND is NULL (looking up GdkWindow for NULL
  HWND always succeeds and returns the root window - not the intended
  effect)
* More logging
* Send DROP_FINISHED event after DnD loop ends
* Send STATUS event on feedback
* Move GetKeyboardState() and related code into _gdk_win32_window_drag_begin(),
  so that it's closer to the point where last_pt and start_pt are set
* Use & 0x80 to check for the key being pressed. Windows will set low-order bit
  to 1 for all mouse buttons to indicate that they are toggled, so simply
  checking for the value not being 0 is not enough anymore.
  This is probably a new thing in modern W32 that didn't exist before
  (OLE2 DnD code is old).
* Fixed (hopefully) and simplified HiDPI parts of the code.

Also adds managed DnD implementation for W32 GDK backend (for both
OLE2 and LOCAL protocols). Mostly a copy of the X11 backend code, but
there are some minor differences:
* doesn't use drag_window field in GdkDragContext,
  uses the one in GdkWin32DragContext exclusively
* subtracts hotspot offset from the window coordinates when showing
  the dragback animation
* tries to consistently support scaling and caches the scale
  in the context
* Some keynav code is removed (places where grabbing/ungrabbing should
  happen is marked with TODOs), and the rest is probably inert.

Also significantly changes the way selection (and clipboard) is handled
(as MSDN rightly notes, the handling for DnD and Clipboard
 formats is virtually the same, so it makes sense to handle
 both with the same code):
* Don't spam GDK_OWNER_CHANGE, send them only when owner
  actually changes
* Open clipboard when our process becomes the clipboard owner
  (we are doing it anyway, to empty the clipboard and *become* the owner),
  and then don't close it until a scheduled selection request event
  (with TARGETS target) is received. Process that event by announcing
  all of our supported formats (by that time add_targets() should have
  been called up the stack, thus the formats are known; just in case,
  add_targets() will also schedule a selection request, if one isn't
  scheduled already, so that late-coming formats can still be announced).
* Allow clipboard opening for selection_convert() to be delayed if it
  fails initially.
* The last two points above should fix all the bugs about GTK+ rising
  too much ruckus over OpenClipboard() failures, as owner change
  *is allowed* to fail (though not all callers currently handle
  that case), and selection_convert() is asynchronous to begin with.
  Still, this is somewhat risky, as there's a possibility that the
  code will work in unexpected ways and the clipboard will remain open.
  There's now logging to track the clipboard being opened and closed,
  and a number of failsafes that try to ensure that it isn't kept open
  for no reason.
* Added copious notes on the way clipboard works on X11, Windows and GDK-W32,
  also removed old comments in DnD implementation, replaced some of them
  with the new ones
* A lot of crufty module-global variables are stuffed into a singleton
  object, GdkWin32Selection. It's technically possible to make it a
  sub-object of the Display object (the way Wayland backend does),
  but since Display object on W32 is a singleton anyway... why bother?
* Fixed the send_change_events() a bit (was slightly broken in one of the
  previous iterations)
* Ensure that there's no confusion between selection conversion (an artifact
  term from X11) and selection transmutation (changing the data to be W32-compatible)
* Put all the transmutation code and format-target-matching code into gdkselection-win32.c,
  now this code isn't spread across multiple files.
* Consequently, moved some code away from gdkproperty-win32.c and gdkdnd-win32.c
* Extensive format transmutation checks for OLE2 DnD and clipboard.
  We now keep track of which format mappings are for transmutations,
  and which aren't (for example, when formats are passed as-is, or when
  a registered name is just an alias)
* Put transmutation code into separate functions

* Ensure that drop target keeps a format->target map for supported formats,
  this is useful when selection_convert() is called, as it only receives a
  single target and no hints on the format from which the data should
  be transmuted into this target.
* Add clear_targets() on W32, to de called by GTK
* Use g_set_object() instead of g_ref_object() where it is allowed.
* Fix indentation (and convert tabs to spaces), remove unused variables

(This commit is cherry-picked from the gtk-3-22 branch)

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Don't leak the atom name string

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: Fix a typo in OLE2 DnD code

https://bugzilla.gnome.org/show_bug.cgi?id=786509

Only register application/x-rootwindow-drop on X11

application/x-rootwindow-drop is not useful anywhere else,
so put it under #ifdef GDK_WINDOWING_X11

On W32 this prevents toplevels from automatically becoming valid
drop targets with a useless drop type.

(This commit is cherry-picked from the gtk-3-22 branch)

https://bugzilla.gnome.org/show_bug.cgi?id=786509

GDK W32: More flexible modal operation mode

Instead of using a boolean to indicate a modal operation being in progress,
use a set of flags, and allow these to be set and unset independently.

Specifically, this allows WM_CAPTURECHANGED handler to only act when a drag-move or
drag-resize modal operation is in progress, and ignore DND (which can also cause
WM_CAPTURECHANGED to be posted). This avoids a crash due to assertion failure when
OLE2 DND code tries to end a modal operation that was already ended by the WM_CAPTURECHANGED
handler.

(This commit is cherry-picked from the gtk-3-22 branch)

https://bugzilla.gnome.org/show_bug.cgi?id=786121

GDK W32: fix monitor pruning code

Decrement the counter for each removed element, otherwise we skip
one element every time we remove one. Also, no need for continue here.

GDK W32: Correctly report window position in HiDPI mode

Window position returned by get_frame_extents() should be scaled.

Also take this opportunity to apply the same rounding that X11 backend
applies.

https://bugzilla.gnome.org/show_bug.cgi?id=788053

GDK-Win32: Fix AeroSnap on HiDPI

Commit 1d0fad3 revealed that there were some assumptions made that were
actually to compensate for the bug fixed by that commit, so we need to
remove those assumptions as they would result in AerSnap to not work
properly on HiDPI screens.

Also re-do how we set the x and y positions of our GdkWindow, so that we
are more consistent across the board when we go between a GDK window
coordinate and a Windows API window cooredinate.

This would also simplify the code a bit.

https://bugzilla.gnome.org/show_bug.cgi?id=785999

GDK W32: Handle drivers that do not send WT_CSRCHANGE after WT_PROXIMITY

Some drivers don't do that (not sure whether that is the correct behaviour
or not). Remember each WT_PROXIMITY with LOWORD(lParam) != 0 that we get,
then look for a WT_CSRCHANGE. If WT_CSRCHANGE doesn't come, but a WT_PACKET
does, assume that this device is the one that sent WT_PROXIMITY.

Also include fallback code to ensure that WT_PACKETs for an enabled device
disable the system pointer, because WT_PROXIMITY handler might have
enabled it by mistake, since it's not possible to know which device left
the proximity (it might have been a disabled device).

https://bugzilla.gnome.org/show_bug.cgi?id=778328

GDK W32: Apply HiDPI scale properly to monitors

Previously HiDPI scale was retrieved and applied too late in the initialization
process to affect monitor size and monitor workarea size, but the code that
initializes these sizes *did* try to use the scale, even though it was always
getting scale=1.

To fix this, move the too-late code into monitor enumeration routine.
This also fixes a probable semantic bug where width and height were divided
by scale, again.

Now monitor and workarea should be in application pixels (i.e. divided by scale),
as intended.

https://bugzilla.gnome.org/show_bug.cgi?id=778835